home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / pygtk / 2.0 / codegen / codegen.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2006-01-20  |  41KB  |  1,042 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import sys
  5. import os
  6. import string
  7. import getopt
  8. import traceback
  9. import keyword
  10. import defsparser
  11. import argtypes
  12. import override
  13. import definitions
  14. import reversewrapper
  15.  
  16. class Coverage(object):
  17.     
  18.     def __init__(self, name):
  19.         self.name = name
  20.         self.wrapped = 0
  21.         self.not_wrapped = 0
  22.  
  23.     
  24.     def declare_wrapped(self):
  25.         self.wrapped += 1
  26.  
  27.     
  28.     def declare_not_wrapped(self):
  29.         self.not_wrapped += 1
  30.  
  31.     
  32.     def printstats(self):
  33.         total = self.wrapped + self.not_wrapped
  34.         if total:
  35.             print >>sys.stderr, '***INFO*** The coverage of %s is %.2f%% (%i/%i)' % (self.name, float(self.wrapped * 100) / total, self.wrapped, total)
  36.         else:
  37.             print >>sys.stderr, '***INFO*** There are no declared %s.' % (self.name,)
  38.  
  39.  
  40. functions_coverage = Coverage('global functions')
  41. methods_coverage = Coverage('methods')
  42. vproxies_coverage = Coverage('virtual proxies')
  43. vaccessors_coverage = Coverage('virtual accessors')
  44. iproxies_coverage = Coverage('interface proxies')
  45.  
  46. def exc_info():
  47.     (etype, value, tb) = sys.exc_info()
  48.     ret = ''
  49.     
  50.     try:
  51.         sval = str(value)
  52.         if etype == KeyError:
  53.             ret = 'No ArgType for %s' % (sval,)
  54.         else:
  55.             ret = sval
  56.     finally:
  57.         del etype
  58.         del value
  59.         del tb
  60.  
  61.     return ret
  62.  
  63.  
  64. def fixname(name):
  65.     if keyword.iskeyword(name):
  66.         return name + '_'
  67.     
  68.     return name
  69.  
  70.  
  71. class FileOutput:
  72.     '''Simple wrapper for file object, that makes writing #line
  73.     statements easier.'''
  74.     
  75.     def __init__(self, fp, filename = None):
  76.         self.fp = fp
  77.         self.lineno = 1
  78.         if filename:
  79.             self.filename = filename
  80.         else:
  81.             self.filename = self.fp.name
  82.  
  83.     
  84.     def write(self, str):
  85.         self.fp.write(str)
  86.         self.lineno = self.lineno + string.count(str, '\n')
  87.  
  88.     
  89.     def writelines(self, sequence):
  90.         for line in sequence:
  91.             self.write(line)
  92.         
  93.  
  94.     
  95.     def close(self):
  96.         self.fp.close()
  97.  
  98.     
  99.     def flush(self):
  100.         self.fp.flush()
  101.  
  102.     
  103.     def setline(self, linenum, filename):
  104.         '''writes out a #line statement, for use by the C
  105.         preprocessor.'''
  106.         self.write('#line %d "%s"\n' % (linenum, filename))
  107.  
  108.     
  109.     def resetline(self):
  110.         '''resets line numbering to the original file'''
  111.         self.setline(self.lineno + 1, self.filename)
  112.  
  113.  
  114.  
  115. class Wrapper:
  116.     type_tmpl = 'PyTypeObject Py%(typename)s_Type = {\n    PyObject_HEAD_INIT(NULL)\n    0,\t\t\t\t\t/* ob_size */\n    "%(classname)s",\t\t\t/* tp_name */\n    sizeof(%(tp_basicsize)s),\t        /* tp_basicsize */\n    0,\t\t\t\t\t/* tp_itemsize */\n    /* methods */\n    (destructor)%(tp_dealloc)s,\t/* tp_dealloc */\n    (printfunc)0,\t\t\t/* tp_print */\n    (getattrfunc)%(tp_getattr)s,\t/* tp_getattr */\n    (setattrfunc)%(tp_setattr)s,\t/* tp_setattr */\n    (cmpfunc)%(tp_compare)s,\t\t/* tp_compare */\n    (reprfunc)%(tp_repr)s,\t\t/* tp_repr */\n    (PyNumberMethods*)%(tp_as_number)s,     /* tp_as_number */\n    (PySequenceMethods*)%(tp_as_sequence)s, /* tp_as_sequence */\n    (PyMappingMethods*)%(tp_as_mapping)s,   /* tp_as_mapping */\n    (hashfunc)%(tp_hash)s,\t\t/* tp_hash */\n    (ternaryfunc)%(tp_call)s,\t\t/* tp_call */\n    (reprfunc)%(tp_str)s,\t\t/* tp_str */\n    (getattrofunc)%(tp_getattro)s,\t/* tp_getattro */\n    (setattrofunc)%(tp_setattro)s,\t/* tp_setattro */\n    (PyBufferProcs*)%(tp_as_buffer)s,\t/* tp_as_buffer */\n    %(tp_flags)s,                      /* tp_flags */\n    NULL, \t\t\t\t/* Documentation string */\n    (traverseproc)%(tp_traverse)s,\t/* tp_traverse */\n    (inquiry)%(tp_clear)s,\t\t/* tp_clear */\n    (richcmpfunc)%(tp_richcompare)s,\t/* tp_richcompare */\n    %(tp_weaklistoffset)s,             /* tp_weaklistoffset */\n    (getiterfunc)%(tp_iter)s,\t\t/* tp_iter */\n    (iternextfunc)%(tp_iternext)s,\t/* tp_iternext */\n    %(tp_methods)s,\t\t\t/* tp_methods */\n    0,\t\t\t\t\t/* tp_members */\n    %(tp_getset)s,\t\t       \t/* tp_getset */\n    NULL,\t\t\t\t/* tp_base */\n    NULL,\t\t\t\t/* tp_dict */\n    (descrgetfunc)%(tp_descr_get)s,\t/* tp_descr_get */\n    (descrsetfunc)%(tp_descr_set)s,\t/* tp_descr_set */\n    %(tp_dictoffset)s,                 /* tp_dictoffset */\n    (initproc)%(tp_init)s,\t\t/* tp_init */\n    (allocfunc)%(tp_alloc)s,           /* tp_alloc */\n    (newfunc)%(tp_new)s,               /* tp_new */\n    (freefunc)%(tp_free)s,             /* tp_free */\n    (inquiry)%(tp_is_gc)s              /* tp_is_gc */\n};\n\n'
  117.     slots_list = [
  118.         'tp_getattr',
  119.         'tp_setattr',
  120.         'tp_getattro',
  121.         'tp_setattro',
  122.         'tp_compare',
  123.         'tp_repr',
  124.         'tp_as_number',
  125.         'tp_as_sequence',
  126.         'tp_as_mapping',
  127.         'tp_hash',
  128.         'tp_call',
  129.         'tp_str',
  130.         'tp_as_buffer',
  131.         'tp_richcompare',
  132.         'tp_iter',
  133.         'tp_iternext',
  134.         'tp_descr_get',
  135.         'tp_descr_set',
  136.         'tp_init',
  137.         'tp_alloc',
  138.         'tp_new',
  139.         'tp_free',
  140.         'tp_is_gc',
  141.         'tp_traverse',
  142.         'tp_clear',
  143.         'tp_dealloc',
  144.         'tp_flags']
  145.     getter_tmpl = 'static PyObject *\n%(funcname)s(PyObject *self, void *closure)\n{\n%(varlist)s    ret = %(field)s;\n%(codeafter)s\n}\n\n'
  146.     parse_tmpl = '    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "%(typecodes)s:%(name)s"%(parselist)s))\n        return %(errorreturn)s;\n'
  147.     deprecated_tmpl = '    if (PyErr_Warn(PyExc_DeprecationWarning, "%(deprecationmsg)s") < 0)\n        return %(errorreturn)s;\n'
  148.     methdef_tmpl = '    { "%(name)s", (PyCFunction)%(cname)s, %(flags)s },\n'
  149.     noconstructor = 'static int\npygobject_no_constructor(PyObject *self, PyObject *args, PyObject *kwargs)\n{\n    gchar buf[512];\n\n    g_snprintf(buf, sizeof(buf), "%s is an abstract widget", self->ob_type->tp_name);\n    PyErr_SetString(PyExc_NotImplementedError, buf);\n    return -1;\n}\n\n'
  150.     function_tmpl = 'static PyObject *\n_wrap_%(cname)s(PyObject *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    %(setreturn)s%(cname)s(%(arglist)s);\n%(codeafter)s\n}\n\n'
  151.     virtual_accessor_tmpl = 'static PyObject *\n_wrap_%(cname)s(PyObject *cls%(extraparams)s)\n{\n    gpointer klass;\n%(varlist)s%(parseargs)s%(codebefore)s    klass = g_type_class_ref(pyg_type_from_object(cls));\n    if (%(class_cast_macro)s(klass)->%(virtual)s)\n        %(setreturn)s%(class_cast_macro)s(klass)->%(virtual)s(%(arglist)s);\n    else {\n        PyErr_SetString(PyExc_NotImplementedError, "virtual method %(name)s not implemented");\n        g_type_class_unref(klass);\n        return NULL;\n    }\n    g_type_class_unref(klass);\n%(codeafter)s\n}\n\n'
  152.     constructor_tmpl = None
  153.     method_tmpl = None
  154.     
  155.     def __init__(self, parser, objinfo, overrides, fp = FileOutput(sys.stdout)):
  156.         self.parser = parser
  157.         self.objinfo = objinfo
  158.         self.overrides = overrides
  159.         self.fp = fp
  160.  
  161.     
  162.     def get_lower_name(self):
  163.         return string.lower(string.replace(self.objinfo.typecode, '_TYPE_', '_', 1))
  164.  
  165.     
  166.     def get_field_accessor(self, fieldname):
  167.         raise NotImplementedError
  168.  
  169.     
  170.     def get_initial_class_substdict(self):
  171.         return { }
  172.  
  173.     
  174.     def get_initial_constructor_substdict(self, constructor):
  175.         return {
  176.             'name': '%s.__init__' % self.objinfo.c_name,
  177.             'errorreturn': '-1' }
  178.  
  179.     
  180.     def get_initial_method_substdict(self, method):
  181.         return {
  182.             'name': '%s.%s' % (self.objinfo.c_name, method.name) }
  183.  
  184.     
  185.     def write_class(self):
  186.         self.fp.write('\n/* ----------- ' + self.objinfo.c_name + ' ----------- */\n\n')
  187.         substdict = self.get_initial_class_substdict()
  188.         if not substdict.has_key('tp_flags'):
  189.             substdict['tp_flags'] = 'Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE'
  190.         
  191.         substdict['typename'] = self.objinfo.c_name
  192.         if self.overrides.modulename:
  193.             substdict['classname'] = '%s.%s' % (self.overrides.modulename, self.objinfo.name)
  194.         else:
  195.             substdict['classname'] = self.objinfo.name
  196.         if not self.overrides.slot_is_overriden('%s.tp_init' % self.objinfo.c_name):
  197.             substdict['tp_init'] = self.write_constructor()
  198.         
  199.         substdict['tp_methods'] = self.write_methods()
  200.         substdict['tp_getset'] = self.write_getsets()
  201.         for slot in self.slots_list:
  202.             slotname = '%s.%s' % (self.objinfo.c_name, slot)
  203.             slotfunc = '_wrap_%s_%s' % (self.get_lower_name(), slot)
  204.             if slot[:6] == 'tp_as_':
  205.                 slotfunc = '&' + slotfunc
  206.             
  207.             if self.overrides.slot_is_overriden(slotname):
  208.                 data = self.overrides.slot_override(slotname)
  209.                 self.write_function(slotname, data)
  210.                 substdict[slot] = slotfunc
  211.                 continue
  212.             if not substdict.has_key(slot):
  213.                 substdict[slot] = '0'
  214.                 continue
  215.         
  216.         self.fp.write(self.type_tmpl % substdict)
  217.         self.write_virtuals()
  218.  
  219.     
  220.     def write_function_wrapper(self, function_obj, template, handle_return = 0, is_method = 0, kwargs_needed = 0, substdict = None):
  221.         '''This function is the guts of all functions that generate
  222.         wrappers for functions, methods and constructors.'''
  223.         if not substdict:
  224.             substdict = { }
  225.         
  226.         info = argtypes.WrapperInfo()
  227.         substdict.setdefault('errorreturn', 'NULL')
  228.         if is_method:
  229.             info.arglist.append('')
  230.         
  231.         if function_obj.varargs:
  232.             raise ValueError, 'varargs functions not supported'
  233.         
  234.         for param in function_obj.params:
  235.             if param.pdflt and '|' not in info.parsestr:
  236.                 info.add_parselist('|', [], [])
  237.             
  238.             handler = argtypes.matcher.get(param.ptype)
  239.             handler.write_param(param.ptype, param.pname, param.pdflt, param.pnull, info)
  240.         
  241.         substdict['setreturn'] = ''
  242.         if handle_return:
  243.             if function_obj.ret not in ('none', None):
  244.                 substdict['setreturn'] = 'ret = '
  245.             
  246.             handler = argtypes.matcher.get(function_obj.ret)
  247.             handler.write_return(function_obj.ret, function_obj.caller_owns_return, info)
  248.         
  249.         if function_obj.deprecated != None:
  250.             deprecated = self.deprecated_tmpl % {
  251.                 'deprecationmsg': function_obj.deprecated,
  252.                 'errorreturn': substdict['errorreturn'] }
  253.         else:
  254.             deprecated = ''
  255.         substdict.setdefault('name', function_obj.name)
  256.         if self.objinfo:
  257.             substdict['typename'] = self.objinfo.c_name
  258.         
  259.         substdict.setdefault('cname', function_obj.c_name)
  260.         substdict['varlist'] = info.get_varlist()
  261.         substdict['typecodes'] = info.parsestr
  262.         substdict['parselist'] = info.get_parselist()
  263.         substdict['arglist'] = info.get_arglist()
  264.         substdict['codebefore'] = deprecated + string.replace(info.get_codebefore(), 'return NULL', 'return ' + substdict['errorreturn'])
  265.         substdict['codeafter'] = string.replace(info.get_codeafter(), 'return NULL', 'return ' + substdict['errorreturn'])
  266.         if info.parsestr or kwargs_needed:
  267.             substdict['parseargs'] = self.parse_tmpl % substdict
  268.             substdict['extraparams'] = ', PyObject *args, PyObject *kwargs'
  269.             flags = 'METH_VARARGS|METH_KEYWORDS'
  270.             substdict['varlist'] = info.get_kwlist() + substdict['varlist']
  271.         else:
  272.             substdict['parseargs'] = ''
  273.             substdict['extraparams'] = ''
  274.             flags = 'METH_NOARGS'
  275.         return (template % substdict, flags)
  276.  
  277.     
  278.     def write_constructor(self):
  279.         initfunc = '0'
  280.         constructor = self.parser.find_constructor(self.objinfo, self.overrides)
  281.         if constructor:
  282.             funcname = constructor.c_name
  283.             
  284.             try:
  285.                 if self.overrides.is_overriden(funcname):
  286.                     data = self.overrides.override(funcname)
  287.                     self.write_function(funcname, data)
  288.                 elif getattr(self, 'write_property_based_constructor', None) is not None:
  289.                     if len(constructor.params) == 0 or isinstance(constructor.params[0], definitions.Property):
  290.                         return self.write_property_based_constructor(constructor)
  291.                     else:
  292.                         print >>sys.stderr, 'Warning: generating old-style constructor for', constructor.c_name
  293.                 
  294.                 code = self.write_function_wrapper(constructor, self.constructor_tmpl, handle_return = 0, is_method = 0, kwargs_needed = 1, substdict = self.get_initial_constructor_substdict(constructor))[0]
  295.                 self.fp.write(code)
  296.                 initfunc = '_wrap_' + funcname
  297.             sys.stderr.write('Could not write constructor for %s: %s\n' % (self.objinfo.c_name, exc_info()))
  298.             initfunc = self.write_noconstructor()
  299.  
  300.         else:
  301.             initfunc = self.write_default_constructor()
  302.         return initfunc
  303.  
  304.     
  305.     def write_noconstructor(self):
  306.         if not hasattr(self.overrides, 'no_constructor_written'):
  307.             self.fp.write(self.noconstructor)
  308.             self.overrides.no_constructor_written = 1
  309.         
  310.         initfunc = 'pygobject_no_constructor'
  311.         return initfunc
  312.  
  313.     
  314.     def write_default_constructor(self):
  315.         return self.write_noconstructor()
  316.  
  317.     
  318.     def get_methflags(self, funcname):
  319.         if self.overrides.wants_kwargs(funcname):
  320.             return 'METH_VARARGS|METH_KEYWORDS'
  321.         elif self.overrides.wants_noargs(funcname):
  322.             return 'METH_NOARGS'
  323.         else:
  324.             return 'METH_VARARGS'
  325.  
  326.     
  327.     def write_function(self, funcname, data):
  328.         (lineno, filename) = self.overrides.getstartline(funcname)
  329.         self.fp.setline(lineno, filename)
  330.         self.fp.write(data)
  331.         self.fp.resetline()
  332.         self.fp.write('\n\n')
  333.  
  334.     
  335.     def _get_class_virtual_substdict(self, meth, cname, parent):
  336.         substdict = self.get_initial_method_substdict(meth)
  337.         substdict['virtual'] = substdict['name'].split('.')[1]
  338.         substdict['cname'] = cname
  339.         substdict['class_cast_macro'] = parent.typecode.replace('_TYPE_', '_', 1) + '_CLASS'
  340.         substdict['typecode'] = self.objinfo.typecode
  341.         substdict['cast'] = string.replace(parent.typecode, '_TYPE_', '_', 1)
  342.         return substdict
  343.  
  344.     
  345.     def write_methods(self):
  346.         methods = []
  347.         klass = self.objinfo.c_name
  348.         for meth in self.parser.find_methods(self.objinfo):
  349.             method_name = meth.c_name
  350.             if self.overrides.is_ignored(method_name):
  351.                 continue
  352.             
  353.             
  354.             try:
  355.                 if self.overrides.is_overriden(method_name):
  356.                     if not self.overrides.is_already_included(method_name):
  357.                         data = self.overrides.override(method_name)
  358.                         self.write_function(method_name, data)
  359.                     
  360.                     methflags = self.get_methflags(method_name)
  361.                 else:
  362.                     (code, methflags) = self.write_function_wrapper(meth, self.method_tmpl, handle_return = 1, is_method = 1, substdict = self.get_initial_method_substdict(meth))
  363.                     self.fp.write(code)
  364.                 methods.append(self.methdef_tmpl % {
  365.                     'name': fixname(meth.name),
  366.                     'cname': '_wrap_' + method_name,
  367.                     'flags': methflags })
  368.                 methods_coverage.declare_wrapped()
  369.             continue
  370.             methods_coverage.declare_not_wrapped()
  371.             sys.stderr.write('Could not write method %s.%s: %s\n' % (klass, meth.name, exc_info()))
  372.             continue
  373.  
  374.         
  375.         for method_name in self.overrides.get_defines_for(klass):
  376.             c_name = override.class2cname(klass, method_name)
  377.             if self.overrides.is_already_included(method_name):
  378.                 continue
  379.             
  380.             
  381.             try:
  382.                 data = self.overrides.define(klass, method_name)
  383.                 self.write_function(method_name, data)
  384.                 methflags = self.get_methflags(method_name)
  385.                 methods.append(self.methdef_tmpl % {
  386.                     'name': method_name,
  387.                     'cname': '_wrap_' + c_name,
  388.                     'flags': methflags })
  389.                 methods_coverage.declare_wrapped()
  390.             continue
  391.             methods_coverage.declare_not_wrapped()
  392.             sys.stderr.write('Could not write method %s.%s: %s\n' % (klass, meth.name, exc_info()))
  393.             continue
  394.  
  395.         
  396.         methods += self.write_virtual_accessors()
  397.         if methods:
  398.             methoddefs = '_Py%s_methods' % self.objinfo.c_name
  399.             methods.append('    { NULL, NULL, 0 }\n')
  400.             self.fp.write('static PyMethodDef %s[] = {\n' % methoddefs)
  401.             self.fp.write(string.join(methods, ''))
  402.             self.fp.write('};\n\n')
  403.         else:
  404.             methoddefs = 'NULL'
  405.         return methoddefs
  406.  
  407.     
  408.     def write_virtual_accessors(self):
  409.         klass = self.objinfo.c_name
  410.         methods = []
  411.         for meth in self.parser.find_virtuals(self.objinfo):
  412.             method_name = self.objinfo.c_name + '__do_' + meth.name
  413.             if self.overrides.is_ignored(method_name):
  414.                 continue
  415.             
  416.             
  417.             try:
  418.                 if self.overrides.is_overriden(method_name):
  419.                     if not self.overrides.is_already_included(method_name):
  420.                         data = self.overrides.override(method_name)
  421.                         self.write_function(method_name, data)
  422.                     
  423.                     methflags = self.get_methflags(method_name)
  424.                 else:
  425.                     meth.params.insert(0, definitions.Parameter(ptype = self.objinfo.c_name + '*', pname = 'self', pdflt = None, pnull = None))
  426.                     
  427.                     try:
  428.                         (code, methflags) = self.write_function_wrapper(meth, self.virtual_accessor_tmpl, handle_return = True, is_method = False, substdict = self._get_class_virtual_substdict(meth, method_name, self.objinfo))
  429.                         self.fp.write(code)
  430.                     finally:
  431.                         del meth.params[0]
  432.  
  433.                 methods.append(self.methdef_tmpl % {
  434.                     'name': 'do_' + fixname(meth.name),
  435.                     'cname': '_wrap_' + method_name,
  436.                     'flags': methflags + '|METH_CLASS' })
  437.                 vaccessors_coverage.declare_wrapped()
  438.             continue
  439.             vaccessors_coverage.declare_not_wrapped()
  440.             sys.stderr.write('Could not write virtual accessor method %s.%s: %s\n' % (klass, meth.name, exc_info()))
  441.             continue
  442.  
  443.         
  444.         return methods
  445.  
  446.     
  447.     def write_virtuals(self):
  448.         '''Write _wrap_FooBar__proxy_do_zbr() reverse wrapers for GObject virtuals'''
  449.         klass = self.objinfo.c_name
  450.         virtuals = []
  451.         for meth in self.parser.find_virtuals(self.objinfo):
  452.             method_name = self.objinfo.c_name + '__proxy_do_' + meth.name
  453.             if self.overrides.is_ignored(method_name):
  454.                 continue
  455.             
  456.             
  457.             try:
  458.                 if self.overrides.is_overriden(method_name):
  459.                     if not self.overrides.is_already_included(method_name):
  460.                         data = self.overrides.override(method_name)
  461.                         self.write_function(method_name, data)
  462.                     
  463.                 else:
  464.                     (ret, props) = argtypes.matcher.get_reverse_ret(meth.ret)
  465.                     wrapper = reversewrapper.ReverseWrapper('_wrap_' + method_name, is_static = True)
  466.                     wrapper.set_return_type(ret(wrapper, **props))
  467.                     wrapper.add_parameter(reversewrapper.PyGObjectMethodParam(wrapper, 'self', method_name = 'do_' + meth.name, c_type = klass + ' *'))
  468.                     for param in meth.params:
  469.                         (handler, props) = argtypes.matcher.get_reverse(param.ptype)
  470.                         wrapper.add_parameter(handler(wrapper, param.pname, **props))
  471.                     
  472.                     buf = reversewrapper.MemoryCodeSink()
  473.                     wrapper.generate(buf)
  474.                     self.fp.write(buf.flush())
  475.                 virtuals.append((fixname(meth.name), '_wrap_' + method_name))
  476.                 vproxies_coverage.declare_wrapped()
  477.             continue
  478.             except KeyError:
  479.                 vproxies_coverage.declare_not_wrapped()
  480.                 virtuals.append((fixname(meth.name), None))
  481.                 sys.stderr.write('Could not write virtual proxy %s.%s: %s\n' % (klass, meth.name, exc_info()))
  482.                 continue
  483.             
  484.  
  485.         
  486.  
  487.     
  488.     def write_getsets(self):
  489.         lower_name = self.get_lower_name()
  490.         getsets_name = lower_name + '_getsets'
  491.         getterprefix = '_wrap_' + lower_name + '__get_'
  492.         setterprefix = '_wrap_' + lower_name + '__set_'
  493.         if not self.objinfo.fields:
  494.             return '0'
  495.         
  496.         getsets = []
  497.         for ftype, fname in self.objinfo.fields:
  498.             gettername = '0'
  499.             settername = '0'
  500.             attrname = self.objinfo.c_name + '.' + fname
  501.             if self.overrides.attr_is_overriden(attrname):
  502.                 code = self.overrides.attr_override(attrname)
  503.                 self.write_function(attrname, code)
  504.                 if string.find(code, getterprefix + fname) >= 0:
  505.                     gettername = getterprefix + fname
  506.                 
  507.                 if string.find(code, setterprefix + fname) >= 0:
  508.                     settername = setterprefix + fname
  509.                 
  510.             
  511.             if gettername == '0':
  512.                 
  513.                 try:
  514.                     funcname = getterprefix + fname
  515.                     info = argtypes.WrapperInfo()
  516.                     handler = argtypes.matcher.get(ftype)
  517.                     handler.write_return(ftype, 0, info)
  518.                     self.fp.write(self.getter_tmpl % {
  519.                         'funcname': funcname,
  520.                         'varlist': info.varlist,
  521.                         'field': self.get_field_accessor(fname),
  522.                         'codeafter': info.get_codeafter() })
  523.                     gettername = funcname
  524.                 sys.stderr.write('Could not write getter for %s.%s: %s\n' % (self.objinfo.c_name, fname, exc_info()))
  525.  
  526.             
  527.             if gettername != '0' or settername != '0':
  528.                 getsets.append('    { "%s", (getter)%s, (setter)%s },\n' % (fixname(fname), gettername, settername))
  529.                 continue
  530.         
  531.         if not getsets:
  532.             return '0'
  533.         
  534.         self.fp.write('static PyGetSetDef %s[] = {\n' % getsets_name)
  535.         for getset in getsets:
  536.             self.fp.write(getset)
  537.         
  538.         self.fp.write('    { NULL, (getter)0, (setter)0 },\n')
  539.         self.fp.write('};\n\n')
  540.         return getsets_name
  541.  
  542.     
  543.     def write_functions(self, prefix):
  544.         self.fp.write('\n/* ----------- functions ----------- */\n\n')
  545.         functions = []
  546.         for func in self.parser.find_functions():
  547.             funcname = func.c_name
  548.             if self.overrides.is_ignored(funcname):
  549.                 continue
  550.             
  551.             
  552.             try:
  553.                 if self.overrides.is_overriden(funcname):
  554.                     data = self.overrides.override(funcname)
  555.                     self.write_function(funcname, data)
  556.                     methflags = self.get_methflags(funcname)
  557.                 else:
  558.                     (code, methflags) = self.write_function_wrapper(func, self.function_tmpl, handle_return = 1, is_method = 0)
  559.                     self.fp.write(code)
  560.                 functions.append(self.methdef_tmpl % {
  561.                     'name': func.name,
  562.                     'cname': '_wrap_' + funcname,
  563.                     'flags': methflags })
  564.                 functions_coverage.declare_wrapped()
  565.             continue
  566.             functions_coverage.declare_not_wrapped()
  567.             sys.stderr.write('Could not write function %s: %s\n' % (func.name, exc_info()))
  568.             continue
  569.  
  570.         
  571.         for funcname in self.overrides.get_functions():
  572.             
  573.             try:
  574.                 data = self.overrides.function(funcname)
  575.                 self.write_function(funcname)
  576.                 methflags = self.get_methflags(funcname)
  577.                 functions.append(self.methdef_tmpl % {
  578.                     'name': funcname,
  579.                     'cname': '_wrap_' + funcname,
  580.                     'flags': methflags })
  581.                 functions_coverage.declare_wrapped()
  582.             continue
  583.             functions_coverage.declare_not_wrapped()
  584.             sys.stderr.write('Could not write function %s: %s\n' % (funcname, exc_info()))
  585.             continue
  586.  
  587.         
  588.         functions.append('    { NULL, NULL, 0 }\n')
  589.         self.fp.write('PyMethodDef ' + prefix + '_functions[] = {\n')
  590.         self.fp.write(string.join(functions, ''))
  591.         self.fp.write('};\n\n')
  592.  
  593.  
  594.  
  595. class GObjectWrapper(Wrapper):
  596.     constructor_tmpl = 'static int\n_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    self->obj = (GObject *)%(cname)s(%(arglist)s);\n%(codeafter)s\n    if (!self->obj) {\n        PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n        return -1;\n    }\n%(aftercreate)s    pygobject_register_wrapper((PyObject *)self);\n    return 0;\n}\n\n'
  597.     method_tmpl = 'static PyObject *\n_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    %(setreturn)s%(cname)s(%(cast)s(self->obj)%(arglist)s);\n%(codeafter)s\n}\n\n'
  598.     
  599.     def __init__(self, parser, objinfo, overrides, fp = FileOutput(sys.stdout)):
  600.         Wrapper.__init__(self, parser, objinfo, overrides, fp)
  601.         if self.objinfo:
  602.             self.castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1)
  603.         
  604.  
  605.     
  606.     def get_initial_class_substdict(self):
  607.         return {
  608.             'tp_basicsize': 'PyGObject',
  609.             'tp_weaklistoffset': 'offsetof(PyGObject, weakreflist)',
  610.             'tp_dictoffset': 'offsetof(PyGObject, inst_dict)' }
  611.  
  612.     
  613.     def get_field_accessor(self, fieldname):
  614.         castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1)
  615.         return '%s(pygobject_get(self))->%s' % (castmacro, fieldname)
  616.  
  617.     
  618.     def get_initial_constructor_substdict(self, constructor):
  619.         substdict = Wrapper.get_initial_constructor_substdict(self, constructor)
  620.         if not constructor.caller_owns_return:
  621.             substdict['aftercreate'] = '    g_object_ref(self->obj);\n'
  622.         else:
  623.             substdict['aftercreate'] = ''
  624.         return substdict
  625.  
  626.     
  627.     def get_initial_method_substdict(self, method):
  628.         substdict = Wrapper.get_initial_method_substdict(self, method)
  629.         substdict['cast'] = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1)
  630.         return substdict
  631.  
  632.     
  633.     def write_default_constructor(self):
  634.         return '0'
  635.  
  636.     
  637.     def write_property_based_constructor(self, constructor):
  638.         out = self.fp
  639.         print >>out, 'static int'
  640.         print >>out, '_wrap_%s(PyGObject *self, PyObject *args, PyObject *kwargs)\n{' % constructor.c_name
  641.         print >>out, '    GType obj_type = pyg_type_from_object((PyObject *) self);'
  642.         
  643.         def py_str_list_to_c(arg):
  644.             if arg:
  645.                 return '{' + ', '.join(map((lambda s: '"' + s + '"'), arg)) + ', NULL }'
  646.             else:
  647.                 return '{ NULL }'
  648.  
  649.         classname = '%s.%s' % (self.overrides.modulename, self.objinfo.name)
  650.         if constructor.params:
  651.             mandatory_arguments = _[1]
  652.             optional_arguments = _[1]
  653.             arg_names = []([ param.argname for param in mandatory_arguments + optional_arguments ])
  654.             prop_names = []([ param.pname for param in mandatory_arguments + optional_arguments ])
  655.             print >>out, '    GParameter params[%i];' % len(constructor.params)
  656.             print >>out, '    PyObject *parsed_args[%i] = {NULL, };' % len(constructor.params)
  657.             print >>out, '    char *arg_names[] = %s;' % arg_names
  658.             print >>out, '    char *prop_names[] = %s;' % prop_names
  659.             print >>out, '    guint nparams, i;'
  660.             print >>out
  661.             print >>out, '    if (!PyArg_ParseTupleAndKeywords(args, kwargs, ',
  662.             template = '"'
  663.             if mandatory_arguments:
  664.                 template += 'O' * len(mandatory_arguments)
  665.             
  666.             if optional_arguments:
  667.                 template += '|' + 'O' * len(optional_arguments)
  668.             
  669.             template += ':%s.__init__"' % classname
  670.             print >>out, template, ', arg_names',
  671.             for i in range(len(constructor.params)):
  672.                 print >>out, ', &parsed_args[%i]' % i,
  673.             
  674.             print >>out, '))'
  675.             print >>out, '        return -1;'
  676.             print >>out
  677.             print >>out, '    memset(params, 0, sizeof(GParameter)*%i);' % len(constructor.params)
  678.             print >>out, '    if (!pyg_parse_constructor_args(obj_type, arg_names, prop_names,'
  679.             print >>out, '                                    params, &nparams, parsed_args))'
  680.             print >>out, '        return -1;'
  681.             print >>out, '    self->obj = g_object_newv(obj_type, nparams, params);'
  682.             print >>out, '    for (i = 0; i < nparams; ++i)'
  683.             print >>out, '        g_value_unset(¶ms[i].value);'
  684.         else:
  685.             print >>out, '    static char* kwlist[] = { NULL };'
  686.             print >>out
  687.             if constructor.deprecated is not None:
  688.                 print >>out, '    if (PyErr_Warn(PyExc_DeprecationWarning, "%s") < 0)' % constructor.deprecated
  689.                 print >>out, '        return -1;'
  690.                 print >>out
  691.             
  692.             print >>out, '    if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":%s.__init__", kwlist))' % classname
  693.             print >>out, '        return -1;'
  694.             print >>out
  695.             print >>out, '    self->obj = g_object_newv(obj_type, 0, NULL);'
  696.         print >>out, '    if (!self->obj) {\n        PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n        return -1;\n    }\n'
  697.         if not constructor.caller_owns_return:
  698.             print >>out, '    g_object_ref(self->obj);\n'
  699.         
  700.         print >>out, '    pygobject_register_wrapper((PyObject *)self);\n    return 0;\n}\n\n' % {
  701.             'typename': classname }
  702.         return '_wrap_%s' % constructor.c_name
  703.  
  704.  
  705.  
  706. class GInterfaceWrapper(GObjectWrapper):
  707.     
  708.     def get_initial_class_substdict(self):
  709.         return {
  710.             'tp_basicsize': 'PyObject',
  711.             'tp_weaklistoffset': '0',
  712.             'tp_dictoffset': '0' }
  713.  
  714.     
  715.     def write_constructor(self):
  716.         return '0'
  717.  
  718.     
  719.     def write_getsets(self):
  720.         return '0'
  721.  
  722.     
  723.     def write_virtual_accessors(self):
  724.         return []
  725.  
  726.     
  727.     def write_virtuals(self):
  728.         klass = self.objinfo.c_name
  729.         proxies = []
  730.         for meth in self.parser.find_virtuals(self.objinfo):
  731.             method_name = self.objinfo.c_name + '__proxy_do_' + meth.name
  732.             if self.overrides.is_ignored(method_name):
  733.                 continue
  734.             
  735.             
  736.             try:
  737.                 if self.overrides.is_overriden(method_name):
  738.                     if not self.overrides.is_already_included(method_name):
  739.                         data = self.overrides.override(method_name)
  740.                         self.write_function(method_name, data)
  741.                     
  742.                 else:
  743.                     (ret, props) = argtypes.matcher.get_reverse_ret(meth.ret)
  744.                     wrapper = reversewrapper.ReverseWrapper('_wrap_' + method_name, is_static = True)
  745.                     wrapper.set_return_type(ret(wrapper, **props))
  746.                     wrapper.add_parameter(reversewrapper.PyGObjectMethodParam(wrapper, 'self', method_name = 'do_' + meth.name, c_type = klass + ' *'))
  747.                     for param in meth.params:
  748.                         (handler, props) = argtypes.matcher.get_reverse(param.ptype)
  749.                         wrapper.add_parameter(handler(wrapper, param.pname, **props))
  750.                     
  751.                     buf = reversewrapper.MemoryCodeSink()
  752.                     wrapper.generate(buf)
  753.                     self.fp.write(buf.flush())
  754.                 proxies.append((fixname(meth.name), '_wrap_' + method_name))
  755.                 iproxies_coverage.declare_wrapped()
  756.             continue
  757.             except KeyError:
  758.                 iproxies_coverage.declare_not_wrapped()
  759.                 proxies.append((fixname(meth.name), None))
  760.                 sys.stderr.write('Could not write interface proxy %s.%s: %s\n' % (klass, meth.name, exc_info()))
  761.                 continue
  762.             
  763.  
  764.         
  765.  
  766.  
  767.  
  768. class GBoxedWrapper(Wrapper):
  769.     constructor_tmpl = 'static int\n_wrap_%(cname)s(PyGBoxed *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    self->gtype = %(typecode)s;\n    self->free_on_dealloc = FALSE;\n    self->boxed = %(cname)s(%(arglist)s);\n%(codeafter)s\n    if (!self->boxed) {\n        PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n        return -1;\n    }\n    self->free_on_dealloc = TRUE;\n    return 0;\n}\n\n'
  770.     method_tmpl = 'static PyObject *\n_wrap_%(cname)s(PyObject *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    %(setreturn)s%(cname)s(pyg_boxed_get(self, %(typename)s)%(arglist)s);\n%(codeafter)s\n}\n\n'
  771.     
  772.     def get_initial_class_substdict(self):
  773.         return {
  774.             'tp_basicsize': 'PyGBoxed',
  775.             'tp_weaklistoffset': '0',
  776.             'tp_dictoffset': '0' }
  777.  
  778.     
  779.     def get_field_accessor(self, fieldname):
  780.         return 'pyg_boxed_get(self, %s)->%s' % (self.objinfo.c_name, fieldname)
  781.  
  782.     
  783.     def get_initial_constructor_substdict(self, constructor):
  784.         substdict = Wrapper.get_initial_constructor_substdict(self, constructor)
  785.         substdict['typecode'] = self.objinfo.typecode
  786.         return substdict
  787.  
  788.  
  789.  
  790. class GPointerWrapper(GBoxedWrapper):
  791.     constructor_tmpl = 'static int\n_wrap_%(cname)s(PyGPointer *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    self->gtype = %(typecode)s;\n    self->pointer = %(cname)s(%(arglist)s);\n%(codeafter)s\n    if (!self->pointer) {\n        PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n        return -1;\n    }\n    return 0;\n}\n\n'
  792.     method_tmpl = 'static PyObject *\n_wrap_%(cname)s(PyObject *self%(extraparams)s)\n{\n%(varlist)s%(parseargs)s%(codebefore)s    %(setreturn)s%(cname)s(pyg_pointer_get(self, %(typename)s)%(arglist)s);\n%(codeafter)s\n}\n\n'
  793.     
  794.     def get_initial_class_substdict(self):
  795.         return {
  796.             'tp_basicsize': 'PyGPointer',
  797.             'tp_weaklistoffset': '0',
  798.             'tp_dictoffset': '0' }
  799.  
  800.     
  801.     def get_field_accessor(self, fieldname):
  802.         return 'pyg_pointer_get(self, %s)->%s' % (self.objinfo.c_name, fieldname)
  803.  
  804.     
  805.     def get_initial_constructor_substdict(self, constructor):
  806.         substdict = Wrapper.get_initial_constructor_substdict(self, constructor)
  807.         substdict['typecode'] = self.objinfo.typecode
  808.         return substdict
  809.  
  810.  
  811.  
  812. def write_headers(data, fp):
  813.     fp.write('/* -- THIS FILE IS GENERATED - DO NOT EDIT */')
  814.     fp.write('/* -*- Mode: C; c-basic-offset: 4 -*- */\n\n')
  815.     fp.write('#include <Python.h>\n\n\n')
  816.     fp.write(data)
  817.     fp.resetline()
  818.     fp.write('\n\n')
  819.  
  820.  
  821. def write_imports(overrides, fp):
  822.     fp.write('/* ---------- types from other modules ---------- */\n')
  823.     for module, pyname, cname in overrides.get_imports():
  824.         fp.write('static PyTypeObject *_%s;\n' % cname)
  825.         fp.write('#define %s (*_%s)\n' % (cname, cname))
  826.     
  827.     fp.write('\n\n')
  828.  
  829.  
  830. def write_type_declarations(parser, fp):
  831.     fp.write('/* ---------- forward type declarations ---------- */\n')
  832.     for obj in parser.boxes:
  833.         fp.write('PyTypeObject Py' + obj.c_name + '_Type;\n')
  834.     
  835.     for obj in parser.objects:
  836.         fp.write('PyTypeObject Py' + obj.c_name + '_Type;\n')
  837.     
  838.     for interface in parser.interfaces:
  839.         fp.write('PyTypeObject Py' + interface.c_name + '_Type;\n')
  840.     
  841.     fp.write('\n')
  842.  
  843.  
  844. def write_classes(parser, overrides, fp):
  845.     for klass, items in ((GBoxedWrapper, parser.boxes), (GPointerWrapper, parser.pointers), (GObjectWrapper, parser.objects), (GInterfaceWrapper, parser.interfaces)):
  846.         for item in items:
  847.             instance = klass(parser, item, overrides, fp)
  848.             instance.write_class()
  849.             fp.write('\n')
  850.         
  851.     
  852.  
  853.  
  854. def write_enums(parser, prefix, fp = sys.stdout):
  855.     if not parser.enums:
  856.         return None
  857.     
  858.     fp.write('\n/* ----------- enums and flags ----------- */\n\n')
  859.     fp.write('void\n' + prefix + '_add_constants(PyObject *module, const gchar *strip_prefix)\n{\n')
  860.     for enum in parser.enums:
  861.         if enum.typecode is None:
  862.             for nick, value in enum.values:
  863.                 fp.write('    PyModule_AddIntConstant(module, pyg_constant_strip_prefix("%s", strip_prefix), %s);\n' % (value, value))
  864.             
  865.         if enum.deftype == 'enum':
  866.             fp.write('  pyg_enum_add(module, "%s", strip_prefix, %s);\n' % (enum.name, enum.typecode))
  867.             continue
  868.         fp.write('  pyg_flags_add(module, "%s", strip_prefix, %s);\n' % (enum.name, enum.typecode))
  869.     
  870.     fp.write('\n')
  871.     fp.write('  if (PyErr_Occurred())\n')
  872.     fp.write('    PyErr_Print();\n')
  873.     fp.write('}\n\n')
  874.  
  875.  
  876. def write_extension_init(overrides, prefix, fp):
  877.     fp.write('/* initialise stuff extension classes */\n')
  878.     fp.write('void\n' + prefix + '_register_classes(PyObject *d)\n{\n')
  879.     imports = overrides.get_imports()[:]
  880.     if imports:
  881.         bymod = { }
  882.         for module, pyname, cname in imports:
  883.             bymod.setdefault(module, []).append((pyname, cname))
  884.         
  885.         fp.write('    PyObject *module;\n\n')
  886.         for module in bymod:
  887.             fp.write('    if ((module = PyImport_ImportModule("%s")) != NULL) {\n' % module)
  888.             fp.write('        PyObject *moddict = PyModule_GetDict(module);\n\n')
  889.             for pyname, cname in bymod[module]:
  890.                 fp.write('        _%s = (PyTypeObject *)PyDict_GetItemString(moddict, "%s");\n' % (cname, pyname))
  891.                 fp.write('        if (_%s == NULL) {\n' % cname)
  892.                 fp.write('            PyErr_SetString(PyExc_ImportError,\n')
  893.                 fp.write('                "cannot import name %s from %s");\n' % (pyname, module))
  894.                 fp.write('            return;\n')
  895.                 fp.write('        }\n')
  896.             
  897.             fp.write('    } else {\n')
  898.             fp.write('        PyErr_SetString(PyExc_ImportError,\n')
  899.             fp.write('            "could not import %s");\n' % module)
  900.             fp.write('        return;\n')
  901.             fp.write('    }\n')
  902.         
  903.         fp.write('\n')
  904.     
  905.     fp.write(overrides.get_init() + '\n')
  906.     fp.resetline()
  907.  
  908.  
  909. def write_registers(parser, fp):
  910.     for boxed in parser.boxes:
  911.         fp.write('    pyg_register_boxed(d, "' + boxed.name + '", ' + boxed.typecode + ', &Py' + boxed.c_name + '_Type);\n')
  912.     
  913.     for pointer in parser.pointers:
  914.         fp.write('    pyg_register_pointer(d, "' + pointer.name + '", ' + pointer.typecode + ', &Py' + pointer.c_name + '_Type);\n')
  915.     
  916.     for interface in parser.interfaces:
  917.         fp.write('    pyg_register_interface(d, "' + interface.name + '", ' + interface.typecode + ', &Py' + interface.c_name + '_Type);\n')
  918.         if interface.interface_info is not None:
  919.             fp.write('    pyg_register_interface_info(%s, &%s);\n' % (interface.typecode, interface.interface_info))
  920.             continue
  921.     
  922.     objects = parser.objects[:]
  923.     pos = 0
  924.     while pos < len(objects):
  925.         parent = objects[pos].parent
  926.         for i in range(pos + 1, len(objects)):
  927.             if objects[i].c_name == parent:
  928.                 objects.insert(i + 1, objects[pos])
  929.                 del objects[pos]
  930.                 break
  931.                 continue
  932.         else:
  933.             pos = pos + 1
  934.     for obj in objects:
  935.         bases = []
  936.         if obj.parent != None:
  937.             bases.append(obj.parent)
  938.         
  939.         bases = bases + obj.implements
  940.         if bases:
  941.             fp.write('    pygobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, Py_BuildValue("(' + 'O' * len(bases) + ')", ' + string.join(map((lambda s: '&Py' + s + '_Type'), bases), ', ') + '));\n')
  942.         else:
  943.             fp.write('    pygobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, NULL);\n')
  944.         if obj.class_init_func is not None:
  945.             fp.write('    pyg_register_class_init(%s, %s);\n' % (obj.typecode, obj.class_init_func))
  946.             continue
  947.     
  948.     fp.write('}\n')
  949.  
  950.  
  951. def write_source(parser, overrides, prefix, fp = FileOutput(sys.stdout)):
  952.     write_headers(overrides.get_headers(), fp)
  953.     write_imports(overrides, fp)
  954.     write_type_declarations(parser, fp)
  955.     write_classes(parser, overrides, fp)
  956.     wrapper = Wrapper(parser, None, overrides, fp)
  957.     wrapper.write_functions(prefix)
  958.     write_enums(parser, prefix, fp)
  959.     write_extension_init(overrides, prefix, fp)
  960.     write_registers(parser, fp)
  961.  
  962.  
  963. def register_types(parser):
  964.     for boxed in parser.boxes:
  965.         argtypes.matcher.register_boxed(boxed.c_name, boxed.typecode)
  966.     
  967.     for pointer in parser.pointers:
  968.         argtypes.matcher.register_pointer(pointer.c_name, pointer.typecode)
  969.     
  970.     for obj in parser.objects:
  971.         argtypes.matcher.register_object(obj.c_name, obj.parent, obj.typecode)
  972.     
  973.     for obj in parser.interfaces:
  974.         argtypes.matcher.register_object(obj.c_name, None, obj.typecode)
  975.     
  976.     for enum in parser.enums:
  977.         if enum.deftype == 'flags':
  978.             argtypes.matcher.register_flag(enum.c_name, enum.typecode)
  979.             continue
  980.         argtypes.matcher.register_enum(enum.c_name, enum.typecode)
  981.     
  982.  
  983. usage = 'usage: codegen.py [-o overridesfile] [-p prefix] defsfile'
  984.  
  985. def main(argv):
  986.     o = override.Overrides()
  987.     prefix = 'pygtk'
  988.     outfilename = None
  989.     errorfilename = None
  990.     (opts, args) = getopt.getopt(argv[1:], 'o:p:r:t:D:', [
  991.         'override=',
  992.         'prefix=',
  993.         'register=',
  994.         'outfilename=',
  995.         'load-types=',
  996.         'errorfilename='])
  997.     defines = { }
  998.     for opt, arg in opts:
  999.         if opt in ('-o', '--override'):
  1000.             o = override.Overrides(arg)
  1001.             continue
  1002.         if opt in ('-p', '--prefix'):
  1003.             prefix = arg
  1004.             continue
  1005.         if opt in ('-r', '--register'):
  1006.             p = defsparser.DefsParser(arg, defines)
  1007.             p.startParsing()
  1008.             register_types(p)
  1009.             del p
  1010.             continue
  1011.         if opt == '--outfilename':
  1012.             outfilename = arg
  1013.             continue
  1014.         if opt == '--errorfilename':
  1015.             errorfilename = arg
  1016.             continue
  1017.         None if opt in ('-t', '--load-types') else None<EXCEPTION MATCH>IndexError
  1018.     
  1019.     if len(args) < 1:
  1020.         print >>sys.stderr, usage
  1021.         return 1
  1022.     
  1023.     if errorfilename:
  1024.         sys.stderr = open(errorfilename, 'w')
  1025.     
  1026.     p = defsparser.DefsParser(args[0], defines)
  1027.     if not outfilename:
  1028.         outfilename = os.path.splitext(args[0])[0] + '.c'
  1029.     
  1030.     p.startParsing()
  1031.     register_types(p)
  1032.     write_source(p, o, prefix, FileOutput(sys.stdout, outfilename))
  1033.     functions_coverage.printstats()
  1034.     methods_coverage.printstats()
  1035.     vproxies_coverage.printstats()
  1036.     vaccessors_coverage.printstats()
  1037.     iproxies_coverage.printstats()
  1038.  
  1039. if __name__ == '__main__':
  1040.     sys.exit(main(sys.argv))
  1041.  
  1042.